home *** CD-ROM | disk | FTP | other *** search
/ QRZ! Ham Radio 1 / QRZ Ham Radio Callsign Database - December 1993.iso / ucsd / packet / tcpip / amiga / asrc29k.lha / ipcmd.c < prev    next >
Encoding:
C/C++ Source or Header  |  1993-01-08  |  8.6 KB  |  429 lines
  1. /* IP-related user commands */
  2. #include <stdio.h>
  3. #include "global.h"
  4. #include "config.h"
  5. #include "mbuf.h"
  6. #include "internet.h"
  7. #include "timer.h"
  8. #include "netuser.h"
  9. #include "iface.h"
  10. #include "ip.h"
  11. #include "cmdparse.h"
  12. #include "commands.h"
  13. #include "rip.h"
  14. #include "rspf.h"
  15. #include "ax25.h"
  16.  
  17. static int doadd __ARGS((int argc,char *argv[],void *p));
  18. static int dodrop __ARGS((int argc,char *argv[],void *p));
  19. static int doflush __ARGS((int argc,char *argv[],void *p));
  20. static int doipaddr __ARGS((int argc,char *argv[],void *p));
  21. static int doipstat __ARGS((int argc,char *argv[],void *p));
  22. static int dolook __ARGS((int argc,char *argv[],void *p));
  23. static int dortimer __ARGS((int argc,char *argv[],void *p));
  24. static int dottl __ARGS((int argc,char *argv[],void *p));
  25. static int dumproute __ARGS((struct route *rp));
  26.  
  27. int doipheard __ARGS((int argc,char *argv[],void *p));
  28.  
  29. static struct cmds Ipcmds[] = {
  30.     "address",    doipaddr,    0,    0, NULLCHAR,
  31.     "heard",    doipheard,    0,    0, NULLCHAR,
  32.     "rtimer",    dortimer,    0,    0, NULLCHAR,
  33.     "status",    doipstat,    0,    0, NULLCHAR,
  34.     "ttl",        dottl,        0,    0, NULLCHAR,
  35.     NULLCHAR,
  36. };
  37.  
  38. /* "route" subcommands */
  39. static struct cmds Rtcmds[] = {
  40.     "add",        doadd,        0,    3,
  41.     "route add <dest addr>[/<bits>] <if name> [gateway] [metric]",
  42.  
  43.     "addprivate",    doadd,        0,    3,
  44.     "route addprivate <dest addr>[/<bits>] <if name> [gateway] [metric]",
  45.  
  46.     "drop",        dodrop,        0,    2,
  47.     "route drop <dest addr>[/<bits>]",
  48.  
  49.     "flush",    doflush,    0,    0,
  50.     NULLCHAR,
  51.  
  52.     "lookup",    dolook,        0,    2,
  53.     "route lookup <dest addr>",
  54.  
  55.     NULLCHAR,
  56. };
  57.  
  58. int doip(argc,argv,p)
  59. int argc;
  60. char *argv[];
  61. void *p;
  62. {
  63.     if(argc == 1)
  64.         return doipheard(argc,argv,p);
  65.     return subcmd(Ipcmds,argc,argv,p);
  66. }
  67.  
  68. static int doipaddr(argc,argv,p)
  69. int argc;
  70. char *argv[];
  71. void *p;
  72. {
  73.     int32 n;
  74.  
  75.     if(argc < 2) {
  76.         tprintf("%s\n",inet_ntoa(Ip_addr));
  77.     } else if((n = resolve(argv[1])) == 0){
  78.         tprintf(Badhost,argv[1]);
  79.         return 1;
  80.     } else
  81.         Ip_addr = n;
  82.     return 0;
  83. }
  84.  
  85. static int dortimer(argc,argv,p)
  86. int argc;
  87. char *argv[];
  88. void *p;
  89. {
  90.     return setlong(&ipReasmTimeout,"IP reasm timeout (sec)",argc,argv);
  91. }
  92.  
  93. static int dottl(argc,argv,p)
  94. int argc;
  95. char *argv[];
  96. void *p;
  97. {
  98.     return setlong(&ipDefaultTTL,"IP Time-to-live",argc,argv);
  99. }
  100.  
  101. /* Display and/or manipulate routing table */
  102. int doroute(argc,argv,p)
  103. int argc;
  104. char *argv[];
  105. void *p;
  106. {
  107.     register int i,bits;
  108.     register struct route *rp;
  109.  
  110.     if(argc >= 2)
  111.         return subcmd(Rtcmds,argc,argv,p);
  112.  
  113.     /* Dump IP routing table
  114.      * Dest            Len Interface    Gateway          Use
  115.      * 192.001.002.003 32  sl0          192.002.003.004  0
  116.      */
  117.     tprintf(
  118. "Dest            Len Interface    Gateway          Metric  P Timer  Use\n");
  119.  
  120.     for(bits=31;bits>=0;bits--){
  121.         for(i=0;i<NROUTE;i++){
  122.             for(rp = Routes[bits][i];rp != NULLROUTE;rp = rp->next){
  123.                 if(dumproute(rp) == EOF)
  124.                     return 0;
  125.             }
  126.         }
  127.     }
  128.     if(R_default.iface != NULLIF)
  129.         dumproute(&R_default);
  130.  
  131.     return 0;
  132. }
  133.  
  134. /* Add an entry to the routing table
  135.  * E.g., "add 1.2.3.4 ax0 5.6.7.8 3"
  136.  */
  137. static int doadd(argc,argv,p)
  138. int argc;
  139. char *argv[];
  140. void *p;
  141. {
  142.     struct iface *ifp;
  143.     int32 dest,gateway;
  144.     unsigned bits;
  145.     char *bitp;
  146.     int32 metric;
  147.     char private;
  148.  
  149.     if(strncmp(argv[0],"addp",4) == 0)
  150.         private = 1;
  151.     else
  152.         private = 0;
  153.     if(strcmp(argv[1],"default") == 0){
  154.         dest = 0;
  155.         bits = 0;
  156.     } else {
  157.         if((dest = resolve(argv[1])) == 0){
  158.             tprintf(Badhost,argv[1]);
  159.             return 1;
  160.         }
  161.  
  162.         /* If IP address is followed by an optional slash and
  163.          * a length field, (e.g., 128.96/16) get it;
  164.          * otherwise assume a full 32-bit address
  165.          */
  166.         if((bitp = strchr(argv[1],'/')) != NULLCHAR){
  167.             bitp++;
  168.             bits = atoi(bitp);
  169.         } else
  170.             bits = 32;
  171.     }
  172.     if((ifp = if_lookup(argv[2])) == NULLIF){
  173.         tprintf(Badinterface,argv[2]);
  174.         return 1;
  175.     }
  176.     if(argc > 3){
  177.         if((gateway = resolve(argv[3])) == 0){
  178.             tprintf(Badhost,argv[3]);
  179.             return 1;
  180.         }
  181.     } else {
  182.         gateway = 0;
  183.     }
  184.     if (argc > 4)
  185.         metric = atol(argv[4]);
  186.     else
  187.         metric = 1;
  188.  
  189.     rt_add(dest,bits,gateway,ifp,metric,0,private);
  190. #ifdef    RSPF
  191.     if(!private)
  192.         rspfrouteupcall(dest,bits,gateway);    /* Do an RSPF upcall */
  193. #endif    /* RSPF */
  194.     return 0;
  195. }
  196.  
  197. /* Drop an entry from the routing table
  198.  * E.g., "drop 128.96/16
  199.  */
  200. static int dodrop(argc,argv,p)
  201. int argc;
  202. char *argv[];
  203. void *p;
  204. {
  205.     char *bitp;
  206.     unsigned bits;
  207.     int32 n;
  208.  
  209.     if(strcmp(argv[1],"default") == 0){
  210.         n = 0;
  211.         bits = 0;
  212.     } else {
  213.         /* If IP address is followed by an optional slash and length field,
  214.          * (e.g., 128.96/16) get it; otherwise assume a full 32-bit address
  215.          */
  216.         if((bitp = strchr(argv[1],'/')) != NULLCHAR){
  217.             bitp++;
  218.             bits = atoi(bitp);
  219.         } else
  220.             bits = 32;
  221.  
  222.         if((n = resolve(argv[1])) == 0){
  223.             tprintf(Badhost,argv[1]);
  224.             return 1;
  225.         }
  226.     }
  227.     return rt_drop(n,bits);
  228. }
  229.  
  230. /* Force a timeout on all temporary routes */
  231. static int doflush(argc,argv,p)
  232. int argc;
  233. char *argv[];
  234. void *p;
  235. {
  236.     register struct route *rp;
  237.     struct route *rptmp;
  238.     int i,j;
  239.     
  240.     if(R_default.timer.state == TIMER_RUN){
  241.         rt_drop(0,0);    /* Drop default route */
  242.     }
  243.     for(i=0;i<NROUTE;i++){
  244.         for(j=0;j<32;j++){
  245.             for(rp = Routes[j][i];rp != NULLROUTE;rp = rptmp){
  246.                 rptmp = rp->next;
  247.                 if(rp->timer.state == TIMER_RUN){
  248.                     rt_drop(rp->target,rp->bits);
  249.                 }
  250.             }
  251.         }
  252.     }
  253.     return 0;
  254. }
  255.  
  256. /* Dump a routing table entry */
  257. static int dumproute(rp)
  258. register struct route *rp;
  259. {
  260.     char *cp;
  261.  
  262.     if(rp->target != 0)
  263.         cp = inet_ntoa(rp->target);
  264.     else
  265.         cp = "default";
  266.     tprintf("%-16s",cp);
  267.     tprintf("%-4u",rp->bits);
  268.     tprintf("%-13s",rp->iface->name);
  269.     if(rp->gateway != 0)
  270.         cp = inet_ntoa(rp->gateway);
  271.     else
  272.         cp = "";
  273.     tprintf("%-17s",cp);
  274.     tprintf("%-8lu",rp->metric);
  275.     tprintf("%c ",(rp->flags & RTPRIVATE) ? 'P' : ' ');
  276.     if(rp->timer.state == TIMER_STOP){
  277.         if(rp->timer.start == 1)tprintf("rspf   ");
  278.         else tprintf("man    ");
  279.     } else tprintf("%-7lu", (MSPTICK * read_timer(&rp->timer)) / 1000);
  280.     return tprintf("%lu\n",rp->uses);
  281. }
  282.  
  283. static int dolook(argc,argv,p)
  284. int argc;
  285. char *argv[];
  286. void *p;
  287. {
  288.     struct route *rp;
  289.     int32 addr;
  290.  
  291.     addr = resolve(argv[1]);
  292.     if(addr == 0){
  293.         tprintf(Badhost,argv[1]);
  294.         return 1;
  295.     }
  296.     if((rp = rt_lookup(addr)) == NULLROUTE){
  297.         tprintf("Host %s (%s) unreachable\n",argv[1],inet_ntoa(addr));
  298.         return 1;
  299.     }
  300.     dumproute(rp);
  301.     return 0;
  302. }
  303.  
  304. static int doipstat(argc,argv,p)
  305. int argc;
  306. char *argv[];
  307. void *p;
  308. {
  309.     register struct reasm *rp;
  310.     register struct frag *fp;
  311.     int i;
  312.  
  313.     for(i=1;i<=NUMIPMIB;i++){
  314.         tprintf("(%2u)%-20s%10lu",i,
  315.          Ip_mib[i].name,Ip_mib[i].value.integer);
  316.         if(i % 2)
  317.             tprintf("     ");
  318.         else
  319.             tprintf("\n");
  320.     }
  321.     if((i % 2) == 0)
  322.         tprintf("\n");
  323.  
  324.     if(Reasmq != NULLREASM)
  325.         tprintf("Reassembly fragments:\n");
  326.     for(rp = Reasmq;rp != NULLREASM;rp = rp->next){
  327.         tprintf("src %s",inet_ntoa(rp->source));
  328.         tprintf(" dest %s",inet_ntoa(rp->dest));
  329.         if(tprintf(" id %u pctl %u time %lu len %u\n",
  330.          rp->id,uchar(rp->protocol),read_timer(&rp->timer),
  331.          rp->length) == EOF)
  332.             break;
  333.         for(fp = rp->fraglist;fp != NULLFRAG;fp = fp->next){
  334.             if(tprintf(" offset %u last %u\n",fp->offset,
  335.             fp->last) == EOF)
  336.                 break;
  337.         }
  338.     }
  339.     return 0;
  340. }
  341.  
  342. /* IP heard structure */
  343. struct iph {
  344.     struct iph *next;
  345.     int32 addr;
  346.     struct iface *iface;
  347.     long count;
  348.     long time;
  349.     char add25[AXALEN];
  350. };
  351. #define NULLIPH (struct iph *)0
  352.  
  353. static struct iph *iph_create __ARGS((int32 addr));
  354. static struct iph *iph_lookup __ARGS((int32 addr));
  355. struct iph *Iph;
  356.  
  357. int doipheard(argc,argv,p)
  358. int argc;
  359. char *argv[];
  360. void *p;
  361. {
  362.     struct iph *iph;
  363.     char tmp[AXBUF];
  364.  
  365.     tprintf("IP Systems Heard:\n"
  366.      "Address          Port       Last Heard       Pkts   Callsign\n");
  367.  
  368.     for(iph=Iph;iph;iph=iph->next)
  369.         tprintf("%-16s %-8s %12s %10d   %-9s\n",
  370.                 inet_ntoa(iph->addr),
  371.                 iph->iface->name,
  372.                 tformat(Clock - iph->time),
  373.                 iph->count,
  374.                 pax25(tmp,iph->add25));
  375.     return 0;
  376. }
  377.  
  378. void log_ipheard(addr,ifp,add25)
  379. int32 addr;
  380. struct iface *ifp;
  381. char *add25;
  382. {
  383.     struct iph *niph;
  384.  
  385.     if((niph = iph_lookup(addr)) == NULLIPH)
  386.         if((niph = iph_create(addr)) == NULLIPH)
  387.             return;
  388.     niph->iface = ifp;
  389.     niph->count++;
  390.     niph->time = Clock;
  391.     memcpy(niph->add25,add25,AXALEN);
  392. }
  393.  
  394. /* Look up an entry in the ip data base */
  395. struct iph *iph_lookup(addr)
  396. int32 addr;
  397. {
  398.     register struct iph *ip;
  399.     struct iph *last = NULLIPH;
  400.  
  401.     for(ip = Iph;ip != NULLIPH;last = ip,ip = ip->next){
  402.         if(ip->addr == addr) {
  403.             if(last != NULLIPH) {
  404.         /* Move entry to top of list */
  405.                 last->next = ip->next;
  406.                 ip->next = Iph;
  407.                 Iph = ip;
  408.         }
  409.             return ip;
  410.     }
  411.     }
  412.     return NULLIPH;
  413. }
  414.  
  415. /* Create a new entry in the source database */
  416. static struct iph *iph_create(addr)
  417. int32 addr;
  418. {
  419.     register struct iph *iph;
  420.  
  421.     iph = (struct iph *)callocw(1,sizeof(struct iph));
  422.  
  423.     iph->addr = addr;
  424.     iph->next = Iph;
  425.     Iph = iph;
  426.  
  427.     return iph;
  428. }
  429.